/**
 * 头像处理工具类
 * 解决微信小程序头像上传的兼容性问题
 */

class AvatarUtils {
  /**
   * 检查是否支持新版头像API
   */
  static canUseNewAvatarAPI() {
    return wx.canIUse('button.open-type.chooseAvatar');
  }

  /**
   * 处理头像文件 - 使用FileSystemManager.saveFile保存临时文件
   * @param {string} tempFilePath 临时文件路径
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static processAvatarFile(tempFilePath, successCallback, failCallback) {
    console.log('开始处理头像文件:', tempFilePath);
    
    // 获取文件系统管理器
    const fs = wx.getFileSystemManager();
    
    // 生成保存文件名
    const timestamp = Date.now();
    const randomStr = Math.random().toString(36).substr(2, 9);
    const fileName = `avatar_${timestamp}_${randomStr}.jpg`;
    const savedFilePath = `${wx.env.USER_DATA_PATH}/${fileName}`;
    
    console.log('准备保存头像文件到:', savedFilePath);
    
    // 使用FileSystemManager.saveFile保存临时文件，解决真机调试问题
    fs.saveFile({
      tempFilePath: tempFilePath,
      filePath: savedFilePath,
      success: (res) => {
        const finalPath = res.savedFilePath || savedFilePath;
        console.log('头像文件保存成功:', finalPath);
        successCallback && successCallback(finalPath);
      },
      fail: (err) => {
        console.error('保存头像文件失败:', err);
        // 如果保存失败，尝试使用wx.saveFile作为降级方案
        console.log('尝试使用wx.saveFile作为降级方案');
        this.fallbackSaveFile(tempFilePath, successCallback, failCallback);
      }
    });
  }

  /**
   * 降级方案：使用wx.saveFile保存文件
   * @param {string} tempFilePath 临时文件路径
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static fallbackSaveFile(tempFilePath, successCallback, failCallback) {
    wx.saveFile({
      tempFilePath: tempFilePath,
      success: (res) => {
        const savedFilePath = res.savedFilePath;
        console.log('降级方案保存头像文件成功:', savedFilePath);
        successCallback && successCallback(savedFilePath);
      },
      fail: (err) => {
        console.error('降级方案保存头像文件失败:', err);
        // 如果所有保存方案都失败，直接使用临时文件路径
        console.log('使用临时文件路径');
        successCallback && successCallback(tempFilePath);
      }
    });
  }

  /**
   * 获取文件扩展名
   * @param {string} filePath 文件路径
   * @returns {string} 文件扩展名
   */
  static getFileExtension(filePath) {
    const match = filePath.match(/\.([^.]+)$/);
    return match ? match[1].toLowerCase() : 'jpg';
  }

  /**
   * 生成安全的文件名
   * @param {string} originalPath 原始文件路径
   * @returns {string} 安全的文件名
   */
  static generateSafeFileName(originalPath) {
    const timestamp = Date.now();
    const randomStr = Math.random().toString(36).substr(2, 9);
    const extension = this.getFileExtension(originalPath);
    return `avatar_${timestamp}_${randomStr}.${extension}`;
  }

  /**
   * 高级文件处理方法 - 支持文件格式检测和优化
   * @param {string} tempFilePath 临时文件路径
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static processAvatarFileAdvanced(tempFilePath, successCallback, failCallback) {
    console.log('开始高级处理头像文件:', tempFilePath);
    
    // 获取文件系统管理器
    const fs = wx.getFileSystemManager();
    
    // 生成安全的文件名
    const fileName = this.generateSafeFileName(tempFilePath);
    const savedFilePath = `${wx.env.USER_DATA_PATH}/${fileName}`;
    
    console.log('准备保存头像文件到:', savedFilePath);
    
    // 首先获取文件信息
    fs.getFileInfo({
      filePath: tempFilePath,
      success: (fileInfo) => {
        console.log('文件信息:', fileInfo);
        
        // 检查文件大小（限制为5MB）
        const maxSize = 5 * 1024 * 1024; // 5MB
        if (fileInfo.size > maxSize) {
          const error = new Error('文件过大，请选择小于5MB的图片');
          failCallback && failCallback(error);
          return;
        }
        
        // 使用FileSystemManager.saveFile保存文件
        fs.saveFile({
          tempFilePath: tempFilePath,
          filePath: savedFilePath,
          success: (res) => {
            const finalPath = res.savedFilePath || savedFilePath;
            console.log('头像文件保存成功:', finalPath);
            successCallback && successCallback(finalPath);
          },
          fail: (err) => {
            console.error('保存头像文件失败:', err);
            // 如果保存失败，尝试使用wx.saveFile作为降级方案
            console.log('尝试使用wx.saveFile作为降级方案');
            this.fallbackSaveFile(tempFilePath, successCallback, failCallback);
          }
        });
      },
      fail: (err) => {
        console.error('获取文件信息失败:', err);
        // 如果获取文件信息失败，直接尝试保存
        this.processAvatarFile(tempFilePath, successCallback, failCallback);
      }
    });
  }

  /**
   * 从相册选择头像
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static chooseFromAlbum(successCallback, failCallback) {
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['album'],
      sizeType: ['compressed'],
      success: (res) => {
        const tempFilePath = res.tempFiles[0].tempFilePath;
        successCallback && successCallback(tempFilePath);
      },
      fail: (err) => {
        console.error('从相册选择头像失败:', err);
        failCallback && failCallback(err);
      }
    });
  }

  /**
   * 拍照选择头像
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static chooseFromCamera(successCallback, failCallback) {
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['camera'],
      sizeType: ['compressed'],
      success: (res) => {
        const tempFilePath = res.tempFiles[0].tempFilePath;
        successCallback && successCallback(tempFilePath);
      },
      fail: (err) => {
        console.error('拍照选择头像失败:', err);
        failCallback && failCallback(err);
      }
    });
  }

  /**
   * 显示头像选择弹窗
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static showAvatarChooseModal(successCallback, failCallback) {
    wx.showActionSheet({
      itemList: ['从相册选择', '拍照'],
      success: (res) => {
        if (res.tapIndex === 0) {
          this.chooseFromAlbum(successCallback, failCallback);
        } else if (res.tapIndex === 1) {
          this.chooseFromCamera(successCallback, failCallback);
        }
      },
      fail: (err) => {
        failCallback && failCallback(err);
      }
    });
  }

  /**
   * 上传头像到服务器
   * @param {string} avatarPath 头像文件路径
   * @param {number} userId 用户ID
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static uploadAvatar(avatarPath, userId, successCallback, failCallback) {
    const app = getApp();
    
    // 检查文件路径是否有效
    if (!avatarPath) {
      console.error('文件路径为空');
      failCallback && failCallback(new Error('文件路径无效，请重新选择头像'));
      return;
    }
    
    wx.uploadFile({
      url: `${app.globalData.baseUrl}/api/user/upload-avatar`,
      filePath: avatarPath,
      name: 'avatar',
      formData: {
        user_id: userId
      },
      success: (res) => {
        try {
          const data = JSON.parse(res.data);
          
          if (data.success && data.data && data.data.avatar_url) {
            // 确保URL是完整的
            let avatarUrl = data.data.avatar_url;
            if (avatarUrl.startsWith('/')) {
              avatarUrl = app.globalData.baseUrl + avatarUrl;
            }
            
            // 上传成功后清理本地临时文件
            this.cleanupTempFile(avatarPath);
            
            // 确保返回相对路径，让前端处理完整URL
            let finalAvatarUrl = avatarUrl;
            if (avatarUrl.startsWith(app.globalData.baseUrl)) {
              finalAvatarUrl = avatarUrl.replace(app.globalData.baseUrl, '');
            }
            
            successCallback && successCallback(finalAvatarUrl, data);
          } else {
            console.error('头像上传失败，服务器返回:', data);
            failCallback && failCallback(data);
          }
        } catch (parseError) {
          console.error('解析头像上传响应失败:', parseError);
          failCallback && failCallback(parseError);
        }
      },
      fail: (err) => {
        console.error('头像上传请求失败:', err);
        failCallback && failCallback(err);
      }
    });
  }

  /**
   * 显示错误提示
   * @param {string} message 错误消息
   */
  static showError(message) {
    wx.showToast({
      title: message || '操作失败',
      icon: 'none'
    });
  }

  /**
   * 显示成功提示
   * @param {string} message 成功消息
   */
  static showSuccess(message) {
    wx.showToast({
      title: message || '操作成功',
      icon: 'success'
    });
  }

  /**
   * 清理临时头像文件
   * @param {string} filePath 要删除的文件路径
   */
  static cleanupTempFile(filePath) {
    if (!filePath || filePath.includes('http://tmp') || filePath.includes('wxfile://')) {
      return; // 不删除临时文件或网络文件
    }

    try {
      const fs = wx.getFileSystemManager();
      fs.unlink({
        filePath: filePath,
        success: () => {
          console.log('临时文件清理成功:', filePath);
        },
        fail: (err) => {
          console.log('临时文件清理失败:', err);
        }
      });
    } catch (err) {
      console.log('清理临时文件时出错:', err);
    }
  }

  /**
   * 获取文件系统信息
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static getFileSystemInfo(successCallback, failCallback) {
    const fs = wx.getFileSystemManager();
    fs.getFileSystemManager().getFileInfo({
      filePath: wx.env.USER_DATA_PATH,
      success: (res) => {
        console.log('文件系统信息:', res);
        successCallback && successCallback(res);
      },
      fail: (err) => {
        console.error('获取文件系统信息失败:', err);
        failCallback && failCallback(err);
      }
    });
  }

  /**
   * 检查文件是否存在
   * @param {string} filePath 文件路径
   * @param {function} successCallback 成功回调
   * @param {function} failCallback 失败回调
   */
  static checkFileExists(filePath, successCallback, failCallback) {
    const fs = wx.getFileSystemManager();
    fs.access({
      path: filePath,
      success: () => {
        successCallback && successCallback(true);
      },
      fail: () => {
        successCallback && successCallback(false);
      }
    });
  }
}

module.exports = AvatarUtils;
